﻿namespace SuperStarRounds.Models
{
  using System;
  using System.Runtime.Serialization;

  [Serializable]
  public class ContentInclusions : ISerializable
  {
    public bool IncludeCoreRules { get; set; } = true;
    public bool IncludeBarbarian { get; set; } = true;
    public bool IncludeBard { get; set; } = true;
    public bool IncludeCleric { get; set; } = true;
    public bool IncludeDruid { get; set; } = true;
    public bool IncludeFighter { get; set; } = true;
    public bool IncludeMonk { get; set; } = true;
    public bool IncludePaladin { get; set; } = true;
    public bool IncludeRanger { get; set; } = true;
    public bool IncludeRogue { get; set; } = true;
    public bool IncludeSorcerer { get; set; } = true;
    public bool IncludeWizard { get; set; } = true;

    public bool IncludeAdvancedPlayersGuide { get; set; } = true;
    public bool IncludeAlchemist { get; set; } = true;
    public bool IncludeAntiPaladin { get; set; } = true;
    public bool IncludeCavalier { get; set; } = true;
    public bool IncludeInquisitor { get; set; } = true;
    public bool IncludeOracle { get; set; } = true;
    public bool IncludeSummoner { get; set; } = true;
    public bool IncludeWitch { get; set; } = true;

    public bool IncludeAdvancedClassGuide { get; set; } = true;
    public bool IncludeArcanist { get; set; } = true;
    public bool IncludeBloodrager { get; set; } = true;
    public bool IncludeBrawler { get; set; } = true;
    public bool IncludeHunter { get; set; } = true;
    public bool IncludeInvestigator { get; set; } = true;
    public bool IncludeShaman { get; set; } = true;
    public bool IncludeSkald { get; set; } = true;
    public bool IncludeSlayer { get; set; } = true;
    public bool IncludeSwashbuckler { get; set; } = true;
    public bool IncludeWarpriest { get; set; } = true;

    public bool IncludeOccultAdventures { get; set; } = true;
    public bool IncludeKineticist { get; set; } = true;
    public bool IncludeMedium { get; set; } = true;
    public bool IncludeMesmerist { get; set; } = true;
    public bool IncludeOccultist { get; set; } = true;
    public bool IncludePsychic { get; set; } = true;
    public bool IncludeSpiritualist { get; set; } = true;

    public bool IncludeUltimateCombat { get; set; } = true;
    public bool IncludeGunslinger { get; set; } = true;
    public bool IncludeNinja { get; set; } = true;
    public bool IncludeSamurai { get; set; } = true;

    public bool IncludeUltimateMagic { get; set; } = true;
    public bool IncludeMagus { get; set; } = true;

    #region setting combinations
    public bool CoreBrb => IncludeCoreRules && IncludeBarbarian;

    public bool CoreBar => IncludeCoreRules && IncludeBard;

    public bool CoreBarCle => IncludeCoreRules && (IncludeBard || IncludeCleric);
    public bool CoreBarCleDru => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludeDruid);
    public bool CoreBarCleDruPal => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludeDruid || IncludePaladin);
    public bool CoreBarCleDruPalSorWiz => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludeDruid || IncludePaladin || IncludeSorcerer || IncludeWizard);
    public bool CoreBarCleDruRan => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludeDruid || IncludeRanger);
    public bool CoreBarCleDruSorWiz => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludeDruid || IncludeSorcerer || IncludeWizard);
    public bool CoreBarClePal => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludePaladin);
    public bool CoreBarClePalSorWiz => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludePaladin || IncludeSorcerer || IncludeWizard);
    public bool CoreBarCleSorWiz => IncludeCoreRules && (IncludeBard || IncludeCleric || IncludeSorcerer || IncludeWizard);
    public bool CoreBarDru => IncludeCoreRules && (IncludeBard || IncludeDruid);
    public bool CoreBarDruRanSorWiz => IncludeCoreRules && (IncludeBard || IncludeDruid || IncludeRanger || IncludeSorcerer || IncludeWizard);
    public bool CoreBarDruSorWiz => IncludeCoreRules && (IncludeBard || IncludeDruid || IncludeSorcerer || IncludeWizard);
    public bool CoreBarPal => IncludeCoreRules && (IncludeBard || IncludePaladin);
    public bool CoreBarRanSorWiz => IncludeCoreRules && (IncludeBard || IncludeRanger || IncludeSorcerer || IncludeWizard);
    public bool CoreBarSorWiz => IncludeCoreRules && (IncludeBard || IncludeSorcerer || IncludeWizard);

    public bool CoreCle => IncludeCoreRules && IncludeCleric;
    public bool CoreCleDru => IncludeCoreRules && (IncludeCleric || IncludeDruid);
    public bool CoreCleDruPalRanSorWiz => IncludeCoreRules && (IncludeCleric || IncludeDruid || IncludePaladin || IncludeRanger || IncludeSorcerer || IncludeWizard);
    public bool CoreCleDruPalSorWiz => IncludeCoreRules && (IncludeCleric || IncludeDruid || IncludePaladin || IncludeSorcerer || IncludeWizard);
    public bool CoreCleDruRan => IncludeCoreRules && (IncludeCleric || IncludeDruid || IncludeRanger);
    public bool CoreCleDruRanSorWiz => IncludeCoreRules && (IncludeCleric || IncludeDruid || IncludeRanger || IncludeSorcerer || IncludeWizard);
    public bool CoreCleDruSorWiz => IncludeCoreRules && (IncludeCleric || IncludeDruid || IncludeSorcerer || IncludeWizard);
    public bool CoreClePal => IncludeCoreRules && (IncludeCleric || IncludePaladin);
    public bool CoreClePalSorWiz => IncludeCoreRules && (IncludeCleric || IncludePaladin || IncludeSorcerer || IncludeWizard);
    public bool CoreCleRan => IncludeCoreRules && (IncludeCleric || IncludeRanger);
    public bool CoreCleSorWiz => IncludeCoreRules && (IncludeCleric || IncludeSorcerer || IncludeWizard);

    public bool CoreDru => IncludeCoreRules && IncludeDruid;
    public bool CoreDruPalRan => IncludeCoreRules && (IncludeDruid || IncludePaladin || IncludeRanger);
    public bool CoreDruRan => IncludeCoreRules && (IncludeDruid || IncludeRanger);
    public bool CoreDruRanSorWiz => IncludeCoreRules && (IncludeDruid || IncludeRanger || IncludeSorcerer || IncludeWizard);
    public bool CoreDruSorWiz => IncludeCoreRules && (IncludeDruid || IncludeSorcerer || IncludeWizard);

    public bool CoreFig => IncludeCoreRules && IncludeFighter;

    public bool CoreMon => IncludeCoreRules && IncludeMonk;

    public bool CorePal => IncludeCoreRules && IncludePaladin;
    public bool CorePalRan => IncludeCoreRules && (IncludePaladin || IncludeRanger);
    public bool CorePalSorWiz => IncludeCoreRules && (IncludePaladin || IncludeSorcerer || IncludeWizard);

    public bool CoreRan => IncludeCoreRules && IncludeRanger;

    public bool CoreRog => IncludeCoreRules && IncludeRogue;

    public bool CoreSor => IncludeCoreRules && IncludeSorcerer;
    public bool CoreSorWiz => IncludeCoreRules && (IncludeSorcerer || IncludeWizard);

    public bool CoreWiz => IncludeCoreRules && IncludeWizard;

    public bool AdvpgAlc => IncludeAdvancedPlayersGuide && IncludeAlchemist;
    public bool AdvpgAlcBarInqSorWizSumWit => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeBard || IncludeInquisitor || IncludeSorcerer || IncludeWizard || IncludeSummoner || IncludeWitch);
    public bool AdvpgAlcCleDruRanSorWizSum => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeCleric || IncludeDruid || IncludeRanger || IncludeSorcerer || IncludeWizard || IncludeSummoner);
    public bool AdvpgAlcDruRan => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeDruid || IncludeRanger);
    public bool AdvpgAlcDruSorWiz => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeDruid || IncludeSorcerer || IncludeWizard);
    public bool AdvpgAlcInqRanWit => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeInquisitor || IncludeRanger || IncludeWitch);
    public bool AdvpgAlcSorWiz => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeSorcerer || IncludeWizard);
    public bool AdvpgAlcSorWizSum => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeSorcerer || IncludeWizard || IncludeSummoner);
    public bool AdvpgAlcWit => IncludeAdvancedPlayersGuide && (IncludeAlchemist || IncludeWitch);

    public bool AdvpgAnt => IncludeAdvancedPlayersGuide && IncludeAntiPaladin;
    public bool AdvpgAntInqPal => IncludeAdvancedPlayersGuide && (IncludeAntiPaladin || IncludeInquisitor || IncludePaladin);
    public bool AdvpgAntPal => IncludeAdvancedPlayersGuide && (IncludeAntiPaladin || IncludePaladin);

    public bool AdvpgBar => IncludeAdvancedPlayersGuide && IncludeBard;
    public bool AdvpgBarCle => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeCleric);
    public bool AdvpgBarCleDruSorWizWit => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeCleric || IncludeDruid || IncludeSorcerer || IncludeWizard || IncludeWitch);
    public bool AdvpgBarCleInq => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeCleric || IncludeInquisitor);
    public bool AdvpgBarCleRanSorWizWit => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeCleric || IncludeRanger || IncludeSorcerer || IncludeWizard || IncludeWitch);
    public bool AdvpgBarDruRan => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeDruid || IncludeRanger);
    public bool AdvpgBarDruSorWiz => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeDruid || IncludeSorcerer || IncludeWizard);
    public bool AdvpgBarInq => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeInquisitor);
    public bool AdvpgBarRan => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeRanger);
    public bool AdvpgBarRanSorWiz => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeRanger || IncludeSorcerer || IncludeWizard);
    public bool AdvpgBarSorWiz => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeSorcerer || IncludeWizard);
    public bool AdvpgBarSorWizWit => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeSorcerer || IncludeWizard || IncludeWitch);
    public bool AdvpgBarWit => IncludeAdvancedPlayersGuide && (IncludeBard || IncludeWitch);

    public bool AdvpgCav => IncludeAdvancedPlayersGuide && IncludeCavalier;

    public bool AdvpgCle => IncludeAdvancedPlayersGuide && IncludeCleric;
    public bool AdvpgCleDru => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeDruid);
    public bool AdvpgCleDruSorWiz => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeDruid || IncludeSorcerer || IncludeWizard);
    public bool AdvpgCleDruSorWizWit => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeDruid || IncludeSorcerer || IncludeWizard || IncludeWitch);
    public bool AdvpgCleInq => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeInquisitor);
    public bool AdvpgCleInqPal => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeInquisitor || IncludePaladin);
    public bool AdvpgCleInqSorWiz => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeInquisitor || IncludeSorcerer || IncludeWizard);
    public bool AdvpgClePal => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludePaladin);
    public bool AdvpgCleSorWiz => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeSorcerer || IncludeWizard);
    public bool AdvpgCleSum => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeSummoner);
    public bool AdvpgCleWit => IncludeAdvancedPlayersGuide && (IncludeCleric || IncludeWitch);

    public bool AdvpgDru => IncludeAdvancedPlayersGuide && IncludeDruid;
    public bool AdvpgDruRan => IncludeAdvancedPlayersGuide && (IncludeDruid || IncludeRanger);
    public bool AdvpgDruRanSorWiz => IncludeAdvancedPlayersGuide && (IncludeDruid || IncludeRanger || IncludeSorcerer || IncludeWizard);
    public bool AdvpgDruSorWiz => IncludeAdvancedPlayersGuide && (IncludeDruid || IncludeSorcerer || IncludeWizard);
    public bool AdvpgDruSorWizSum => IncludeAdvancedPlayersGuide && (IncludeDruid || IncludeSorcerer || IncludeWizard || IncludeSummoner);
    public bool AdvpgDruSorWizSumWit => IncludeAdvancedPlayersGuide && (IncludeDruid || IncludeSorcerer || IncludeWizard || IncludeSummoner || IncludeWitch);
    public bool AdvpgDruSorWizWit => IncludeAdvancedPlayersGuide && (IncludeDruid || IncludeSorcerer || IncludeWizard || IncludeWitch);
    public bool AdvpgDruWit => IncludeAdvancedPlayersGuide && (IncludeDruid || IncludeWitch);

    public bool AdvpgInq => IncludeAdvancedPlayersGuide && IncludeInquisitor;
    public bool AdvpgInqPal => IncludeAdvancedPlayersGuide && (IncludeInquisitor || IncludePaladin);
    public bool AdvpgInqRan => IncludeAdvancedPlayersGuide && (IncludeInquisitor || IncludeRanger);
    public bool AdvpgInqWit => IncludeAdvancedPlayersGuide && (IncludeInquisitor || IncludeWitch);

    public bool AdvpgOra => IncludeAdvancedPlayersGuide && IncludeOracle;

    public bool AdvpgPal => IncludeAdvancedPlayersGuide && IncludePaladin;

    public bool AdvpgRan => IncludeAdvancedPlayersGuide && IncludeRanger;
    public bool AdvpgRanSorWiz => IncludeAdvancedPlayersGuide && (IncludeRanger || IncludeSorcerer || IncludeWizard);

    public bool AdvpgSorWiz => IncludeAdvancedPlayersGuide && (IncludeSorcerer || IncludeWizard);
    public bool AdvpgSorWizSum => IncludeAdvancedPlayersGuide && (IncludeSorcerer || IncludeWizard || IncludeSummoner);
    public bool AdvpgSorWizWit => IncludeAdvancedPlayersGuide && (IncludeSorcerer || IncludeWizard || IncludeWitch);

    public bool AdvpgSum => IncludeAdvancedPlayersGuide && IncludeSummoner;

    public bool AdvpgWit => IncludeAdvancedPlayersGuide && IncludeWitch;

    public bool AdvcgArc => IncludeAdvancedClassGuide && IncludeArcanist;

    public bool AdvcgBlo => IncludeAdvancedClassGuide && IncludeBloodrager;

    public bool AdvcgBra => IncludeAdvancedClassGuide && IncludeBrawler;

    public bool AdvcgHun => IncludeAdvancedClassGuide && IncludeHunter;

    public bool AdvcgInv => IncludeAdvancedClassGuide && IncludeInvestigator;

    public bool AdvcgSha => IncludeAdvancedClassGuide && IncludeShaman;

    public bool AdvcgSka => IncludeAdvancedClassGuide && IncludeSkald;

    public bool AdvcgSla => IncludeAdvancedClassGuide && IncludeSlayer;

    public bool AdvcgSwa => IncludeAdvancedClassGuide && IncludeSwashbuckler;

    public bool AdvcgWar => IncludeAdvancedClassGuide && IncludeWarpriest;

    public bool OccKin => IncludeOccultAdventures && IncludeKineticist;

    public bool OccMed => IncludeOccultAdventures && IncludeMedium;

    public bool OccMes => IncludeOccultAdventures && IncludeMesmerist;

    public bool OccOcc => IncludeOccultAdventures && IncludeOccultist;

    public bool OccPsy => IncludeOccultAdventures && IncludePsychic;

    public bool OccSpi => IncludeOccultAdventures && IncludeSpiritualist;

    public bool UltCoGun => IncludeUltimateCombat && IncludeGunslinger;

    public bool UltCoNin => IncludeUltimateCombat && IncludeNinja;

    public bool UltCoSam => IncludeUltimateCombat && IncludeSamurai;

    public bool UltMaMag => IncludeUltimateMagic && IncludeMagus;
    #endregion

    /// <summary>
    /// Initializes a new instance of the <see cref="ContentInclusions"/> class.
    /// This is the base constructor.
    /// </summary>
    public ContentInclusions()
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ContentInclusions"/> class.
    /// This is the serializarion interface constructor.
    /// </summary>
    /// <param name="info">Serialization info packet containing the loaded data</param>
    /// <param name="ctxt">Streaming context of the data packet</param>
    public ContentInclusions(SerializationInfo info, StreamingContext ctxt)
    {
      IncludeCoreRules = GetBooleanDefaultingTrue(info, "IncludeCoreRules");
      IncludeBarbarian = GetBooleanDefaultingTrue(info, "IncludeBarbarian");
      IncludeBard = GetBooleanDefaultingTrue(info, "IncludeBard");
      IncludeCleric = GetBooleanDefaultingTrue(info, "IncludeCleric");
      IncludeDruid = GetBooleanDefaultingTrue(info, "IncludeDruid");
      IncludeFighter = GetBooleanDefaultingTrue(info, "IncludeFighter");
      IncludeMonk = GetBooleanDefaultingTrue(info, "IncludeMonk");
      IncludePaladin = GetBooleanDefaultingTrue(info, "IncludePaladin");
      IncludeRanger = GetBooleanDefaultingTrue(info, "IncludeRanger");
      IncludeRogue = GetBooleanDefaultingTrue(info, "IncludeRogue");
      IncludeSorcerer = GetBooleanDefaultingTrue(info, "IncludeSorcerer");
      IncludeWizard = GetBooleanDefaultingTrue(info, "IncludeWizard");

      IncludeAdvancedPlayersGuide = GetBooleanDefaultingTrue(info, "IncludeAdvancedPlayersGuide");
      IncludeAlchemist = GetBooleanDefaultingTrue(info, "IncludeAlchemist");
      IncludeAntiPaladin = GetBooleanDefaultingTrue(info, "IncludeAntiPaladin");
      IncludeCavalier = GetBooleanDefaultingTrue(info, "IncludeCavalier");
      IncludeInquisitor = GetBooleanDefaultingTrue(info, "IncludeInquisitor");
      IncludeOracle = GetBooleanDefaultingTrue(info, "IncludeOracle");
      IncludeSummoner = GetBooleanDefaultingTrue(info, "IncludeSummoner");
      IncludeWitch = GetBooleanDefaultingTrue(info, "IncludeWitch");

      IncludeAdvancedClassGuide = GetBooleanDefaultingTrue(info, "IncludeAdvancedClassGuide");
      IncludeArcanist = GetBooleanDefaultingTrue(info, "IncludeArcanist");
      IncludeBloodrager = GetBooleanDefaultingTrue(info, "IncludeBloodrager");
      IncludeBrawler = GetBooleanDefaultingTrue(info, "IncludeBrawler");
      IncludeHunter = GetBooleanDefaultingTrue(info, "IncludeHunter");
      IncludeInvestigator = GetBooleanDefaultingTrue(info, "IncludeInvestigator");
      IncludeShaman = GetBooleanDefaultingTrue(info, "IncludeShaman");
      IncludeSkald = GetBooleanDefaultingTrue(info, "IncludeSkald");
      IncludeSlayer = GetBooleanDefaultingTrue(info, "IncludeSlayer");
      IncludeSwashbuckler = GetBooleanDefaultingTrue(info, "IncludeSwashbuckler");
      IncludeWarpriest = GetBooleanDefaultingTrue(info, "IncludeWarpriest");

      IncludeOccultAdventures = GetBooleanDefaultingTrue(info, "IncludeOccultAdventures");
      IncludeKineticist = GetBooleanDefaultingTrue(info, "IncludeKineticist");
      IncludeMedium = GetBooleanDefaultingTrue(info, "IncludeMedium");
      IncludeMesmerist = GetBooleanDefaultingTrue(info, "IncludeMesmerist");
      IncludeOccultist = GetBooleanDefaultingTrue(info, "IncludeOccultist");
      IncludePsychic = GetBooleanDefaultingTrue(info, "IncludePsychic");
      IncludeSpiritualist = GetBooleanDefaultingTrue(info, "IncludeSpiritualist");

      IncludeUltimateCombat = GetBooleanDefaultingTrue(info, "IncludeUltimateCombat");
      IncludeGunslinger = GetBooleanDefaultingTrue(info, "IncludeGunslinger");
      IncludeNinja = GetBooleanDefaultingTrue(info, "IncludeNinja");
      IncludeSamurai = GetBooleanDefaultingTrue(info, "IncludeSamurai");

      IncludeUltimateMagic = GetBooleanDefaultingTrue(info, "IncludeUltimateMagic");
      IncludeMagus = GetBooleanDefaultingTrue(info, "IncludeMagus");
    }

    private static bool GetBooleanDefaultingTrue(SerializationInfo info, string key)
    {
      try
      {
        return info.GetBoolean(key);
      }
      catch (Exception)
      {
        return true;
      }
    }

    /// <summary>
    /// Retrieves the serialized data from the context input stream.
    /// </summary>
    /// <param name="info">Serialization info packet referencing the save file</param>
    /// <param name="ctxt">Streaming context of the save file</param>
    public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
    {
      info.AddValue("IncludeCoreRules", IncludeCoreRules);
      info.AddValue("IncludeBarbarian", IncludeBarbarian);
      info.AddValue("IncludeBard", IncludeBard);
      info.AddValue("IncludeCleric", IncludeCleric);
      info.AddValue("IncludeDruid", IncludeDruid);
      info.AddValue("IncludeFighter", IncludeFighter);
      info.AddValue("IncludeMonk", IncludeMonk);
      info.AddValue("IncludePaladin", IncludePaladin);
      info.AddValue("IncludeRanger", IncludeRanger);
      info.AddValue("IncludeRogue", IncludeRogue);
      info.AddValue("IncludeSorcerer", IncludeSorcerer);
      info.AddValue("IncludeWizard", IncludeWizard);

      info.AddValue("IncludeAdvancedPlayersGuide", IncludeAdvancedPlayersGuide);
      info.AddValue("IncludeAlchemist", IncludeAlchemist);
      info.AddValue("IncludeAntiPaladin", IncludeAntiPaladin);
      info.AddValue("IncludeCavalier", IncludeCavalier);
      info.AddValue("IncludeInquisitor", IncludeInquisitor);
      info.AddValue("IncludeOracle", IncludeOracle);
      info.AddValue("IncludeSummoner", IncludeSummoner);
      info.AddValue("IncludeWitch", IncludeWitch);

      info.AddValue("IncludeAdvancedClassGuide", IncludeAdvancedClassGuide);
      info.AddValue("IncludeArcanist", IncludeArcanist);
      info.AddValue("IncludeBloodrager", IncludeBloodrager);
      info.AddValue("IncludeBrawler", IncludeBrawler);
      info.AddValue("IncludeHunter", IncludeHunter);
      info.AddValue("IncludeInvestigator", IncludeInvestigator);
      info.AddValue("IncludeShaman", IncludeShaman);
      info.AddValue("IncludeSkald", IncludeSkald);
      info.AddValue("IncludeSlayer", IncludeSlayer);
      info.AddValue("IncludeSwashbuckler", IncludeSwashbuckler);
      info.AddValue("IncludeWarpriest", IncludeWarpriest);

      info.AddValue("IncludeOccultAdventures", IncludeOccultAdventures);
      info.AddValue("IncludeKineticist", IncludeKineticist);
      info.AddValue("IncludeMedium", IncludeMedium);
      info.AddValue("IncludeMesmerist", IncludeMesmerist);
      info.AddValue("IncludeOccultist", IncludeOccultist);
      info.AddValue("IncludePsychic", IncludePsychic);
      info.AddValue("IncludeSpiritualist", IncludeSpiritualist);

      info.AddValue("IncludeUltimateCombat", IncludeUltimateCombat);
      info.AddValue("IncludeGunslinger", IncludeGunslinger);
      info.AddValue("IncludeNinja", IncludeNinja);
      info.AddValue("IncludeSamurai", IncludeSamurai);

      info.AddValue("IncludeUltimateMagic", IncludeUltimateMagic);
      info.AddValue("IncludeMagus", IncludeMagus);
    }
  }
}